﻿using System;
using System.Collections;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Xml.Linq;
using System.Collections.Generic;
using Heckel.EasyTools.Diagramming;
using System.IO;
using System.Text;
using System.Data.SqlClient;

namespace GesWork.actividades
{
    public partial class padres : System.Web.UI.Page
    {

        const int longitudNombreCuaderno = 30;

        protected void Page_Load(object sender, EventArgs e)
        {
            //ArrayList hijos;
            string idPadre = Request.QueryString["id"];
            string nombreFichero = idPadre;
           

            if (!Page.IsPostBack && idPadre!=null)
            {
                crearNodoPadre(getNameByID(nombreFichero), nombreFichero);
                getHijos(nombreFichero);
                
            }
        }

        protected void visualizarHijos(List<string> fila)
        {
            //Response.Write("<br/>" + fila[1]);
            agregarNodo(fila[2],fila[1],fila[0]);
            
        }

        protected void getHijos(string idPadre)
        {
         //string idPadre = cmbPadres.SelectedValue;

            ArrayList listado = new ArrayList(); ;
         SqlConnection cn = new SqlConnection(ConfigurationManager.ConnectionStrings["gesworkConnectionString"].ConnectionString);

         SqlDataAdapter daCliente = new SqlDataAdapter("Select id, subject, idtouser FROM Activity where idtouser = " + idPadre, cn);
         DataSet ds = new DataSet();
         daCliente.Fill(ds, "Activity");
         //carga de datos de clientes en el ComboBox
         foreach (DataRow pRow in ds.Tables["Activity"].Rows)
         {
             List<string> fila= new List<string>();
             fila.Add(pRow["id"].ToString());
             fila.Add(pRow["subject"].ToString());
             fila.Add(pRow["idtouser"].ToString());
             listado.Add(fila);
         }
            
         //liberar recursos
         daCliente.Dispose();
         ds.Dispose();

         foreach (List<string> fila in listado)
                {
                 visualizarHijos( fila);
                 getHijos(fila[0]);
                }
        
        //return listado;
        

        }

        protected string getNameByID(String id)
        { 
        
         SqlConnection cn = new SqlConnection(ConfigurationManager.ConnectionStrings["gesworkConnectionString"].ConnectionString);

         SqlDataAdapter daCliente = new SqlDataAdapter("Select id, subject FROM Activity where id = " + id, cn);
         DataSet ds = new DataSet();
         daCliente.Fill(ds, "Activity");

         return  ds.Tables["Activity"].Rows[0][1].ToString();
        }


        protected void cargarNodos(object sender, EventArgs e)
        {

            string idPadre = ((DropDownList)sender).SelectedValue;
            Response.Redirect("diagrama.aspx?id=" + idPadre);
            //Response.Write(idPadre);
            



            //DiagramContainer1.AllNodes.Add(
            //        new Heckel.EasyTools.Diagramming.DiagramNode("../images/activity.png",
            //            "PARENT NODE TITLE", "PARENT NODE DESCRIPTION", "UniqueClientId" + DiagramContainer1.AllNodes.Count, 1, 178, 240, new List<string>(), 
            //            new List<string>()));

            //    List<string> allParent = new List<string>();
            //    allParent.Add("UniqueClientId1");

            //    DiagramContainer1.AllNodes.Add(
            //        new Heckel.EasyTools.Diagramming.DiagramNode("../images/activity.png",
            //            "CHILD NODE TITLE", "CHILD NODE DESCRIPTION", "UniqueClientId" + DiagramContainer1.AllNodes.Count, 2, 40, 130,
            //            new List<string>(), allParent));

            //string nombreFichero = "Nodo" + DiagramContainer1.AllNodes.Count;

            //if (DiagramContainer1.AllNodes.Count > 0)
            //{
            //    DiagramNode destino = null;
            //    for (int i = 0; i < DiagramContainer1.AllNodes.Count; i++)
            //    {
            //        if (DiagramContainer1.AllNodes[i].ParentOfIds.Count == 0)
            //        {
            //            destino = DiagramContainer1.AllNodes[i];
            //        }
            //    }
            //    agregarNodo(destino.NodeID, nombreFichero);

            //}
            //else
            //{
            //    crearNodoPadre(nombreFichero);
            //}

        }
        private void recogeInfoServidor(string info, string nombre)
        {
            //string info="";
            //string info = Request.Form[0];
            //string XML = Request.Form[0];
            if (Session["diagrama"] != null)
            {
                DiagramContainer1 = (DiagramContainer)Session["diagrama"];
            }

            if (info == "eliminar")
            {


                string idn = (string)Session["NodoDoubleClick"];
                //eliminarNodo_Modal(idn);
                eliminarNodo(idn);

                //StringBuilder sb = new StringBuilder();
                //sb.Append("parent.document.forms[0].submit();");
                //return sb.ToString();
            }
            else
            {
                if (info != "-1")
                {
                    int pos = Convert.ToInt32(info);
                    string idn = (string)Session["NodoDoubleClick"];
                    //DiagramNode nodo =null;
                    DiagramNode padre = null;
                    foreach (DiagramNode d in DiagramContainer1.AllNodes)
                    {
                        if (d.ChildOfIds.Count == 0)
                        {
                            padre = d;
                        }
                        //if(d.NodeID ==idn)
                        //{
                        //    nodo=d;
                        //}
                    }

                    int posoriginal = 0;

                    if (padre.NodeID == idn)
                    {

                    }
                    else
                    {
                        bool encontrado = false;
                        do
                        {
                            if (padre.ParentOfIds.Count != 0)
                            {
                                foreach (DiagramNode d in DiagramContainer1.AllNodes)
                                {
                                    if (d.NodeID == padre.ParentOfIds[0])
                                    {
                                        padre = d;
                                        posoriginal++;
                                        if (d.NodeID == idn)
                                        {
                                            encontrado = true;
                                        }
                                        break;
                                    }

                                }
                            }
                        }
                        while (padre.ParentOfIds.Count != 0 && encontrado == false);
                    }
                    if (pos != posoriginal)
                        Reposicionar(idn, pos);

                    //StringBuilder sb = new StringBuilder();
                    //sb.Append("parent.document.forms[0].submit();");
                    //return sb.ToString();
                }
                else
                {

                }
            }

            if (nombre != "-1")
            {
                string idn = (string)Session["NodoDoubleClick"];
                CambiarNombreCuaderno(nombre, idn);

                //StringBuilder sb = new StringBuilder();
                //sb.Append("parent.document.forms[0].submit();");
                //Page.ClientScript.RegisterStartupScript(this.GetType(), "refresco", sb.ToString());

            }
            //if (info == "reposicionar")
            //{
            //    DiagramContainer1 = (DiagramContainer)Session["diagrama"];
            //    string idn = (string)Session["NodoDoubleClick"];
            //    Reposicionar(idn, 0);
            //}
        }

        //private void eliminarNodo_Modal(string idn)
        //{
        //    eliminarNodo(idn);
        //    Repintar();
        //}

        private void CambiarNombreCuaderno(string nombre, string idNodo)
        {

            //if (Session["diagrama"] != null)
            //{
            //    DiagramContainer1 = (DiagramContainer)Session["diagrama"];
            //}


            //// Código actualmente comentado ya que no funciona correctamente el renombrar después de venir de la descarga.
            //string urlScorm = Server.MapPath("./tmp/" + ((ScormCreacion.ScormCreacion)Session["scorm"]).ObtenerId() + "/" + idNodo + "/");

            ////string urlScormDestino = Server.MapPath("./tmp/" + ((ScormCreacion.ScormCreacion)Session["scorm"]).ObtenerId() + "/" + nombre);
            ////if(Directory.Exists(urlScorm))
            ////  Directory.Move(urlScorm,urlScormDestino);

            //DiagramNode nodo = null;

            ///*
            //foreach (HttpPostedFileAJAX fichero in fileUpload1.History)
            //{
            //    if (fichero.FileName_SavedAs == urlScorm)
            //        fichero.FileName_SavedAs = urlnueva; 
            //}*/

            ////Cogemos el nodo que queremos renombrar
            //foreach (DiagramNode d in DiagramContainer1.AllNodes)
            //{
            //    if (d.NodeID == idNodo)
            //    {
            //        nodo = DiagramContainer1.AllNodes[DiagramContainer1.AllNodes.IndexOf(d)];
            //        break;
            //    }
            //}

            //int ddlpos = 0;

            //List<Cuaderno> l = (List<Cuaderno>)Session["lstCuadernos"];
            //for (int i = 0; i < l.Count; i++)
            //{
            //    if (l[i].Nombre == idNodo)
            //    {
            //        ddlpos = i;
            //    }
            //}

          

            //ScormCreacion.ScormCreacion scorm = (ScormCreacion.ScormCreacion)Session["scorm"];

            //if (File.Exists(Server.MapPath("./tmp/" + scorm.ObtenerId() + "/" + idNodo + ".zip")))
            //{

            //    urlScorm = Server.MapPath("./tmp/" + scorm.ObtenerId() + "/" + idNodo + ".zip");
            //    string urlnueva = Server.MapPath("./tmp/" + ((ScormCreacion.ScormCreacion)Session["scorm"]).ObtenerId() + "/" + recortarAnCaracteres(nombre, longitudNombreCuaderno) + ".zip");
            //    File.Move(urlScorm, urlnueva);
            //    nodo.NodeID = recortarAnCaracteres(nombre, longitudNombreCuaderno);
            //    nodo.NodeText = recortarAnCaracteres(nombre, longitudNombreCuaderno);

               
            //    l[ddlpos].Nombre = nodo.NodeID;
            //    l[ddlpos].Url = urlnueva;
            //    Session["lstCuadernos"] = l;
            //}
            //else if (Directory.Exists(urlScorm))
            //{
            //    string urlnueva = Server.MapPath("./tmp/" + scorm.ObtenerId() + "/" + recortarAnCaracteres(nombre, longitudNombreCuaderno) + "/");
            //    //Directory.Move(urlScorm,urlnueva);
            //    CopiaDirectorio(urlScorm, urlnueva);
            //    nodo.NodeID = recortarAnCaracteres(nombre, longitudNombreCuaderno);
            //    nodo.NodeText = recortarAnCaracteres(nombre, longitudNombreCuaderno);
            //    l[ddlpos].Nombre = nodo.NodeID;
            //    l[ddlpos].Url = urlnueva;
            //    Session["lstCuadernos"] = l;

            //}

            //CambiarReferenciasPorNuevoID(nodo.NodeID, idNodo);

            //salvarDiagramaASession();

            ////logger.Debug("Cambio de nombre finalizado " + nombre);
        }




        private void CambiarReferenciasPorNuevoID(string nombre, string idNodo)
        {
            foreach (DiagramNode d in DiagramContainer1.AllNodes)
            {
                if (d.ChildOfIds.Count != 0)
                {
                    if (d.ChildOfIds[0] == idNodo)
                    {
                        d.ChildOfIds[0] = nombre;
                    }
                }
                if (d.ParentOfIds.Count != 0)
                {
                    if (d.ParentOfIds[0] == idNodo)
                    {
                        d.ParentOfIds[0] = nombre;
                    }
                }
            }
        }




        /// <summary>
        /// Entra en el modalbox
        /// </summary>
        /// <param name="o"></param>
        /// <param name="e"></param>
        protected void NodoDoubleClick(object o, NodeDetailsEventArgs e)
        {
            NodeDetailsEventArgs nd = (NodeDetailsEventArgs)e;
            bool valido = true;

            //foreach (DiagramNode nodo in DiagramContainer1.AllNodes)
            //{
            //    if (nodo.NodeID == nd.NodeID && nodo.ImageUrl == "../images/activityError.png")
            //        valido = false;
            //    else if (nodo.NodeID == nd.NodeID && nodo.ImageUrl == "../images/activityErrorFlecha.png")
            //        valido = false;
            //}
            if (valido)
            {
                salvarDiagramaASession();
                nd.ModalDialogueHeight = 635;
                nd.ModalDialogueWidth = 725;
                //nd.ModalDialogueHtmlToDisplay = "actividad.aspx?id=" + nd.NodeID ;
                nd.ModalDialogueHtmlToDisplay = "actividadPupPop.aspx?id=" + nd.NodeID;
               

            }
            //else
            //{
            //    salvarDiagramaASession();
            //    nd.ModalDialogueHeight = 320;
            //    nd.ModalDialogueHtmlToDisplay = "cuadernonoscorm.aspx";
            //}

            Session["NodoDoubleClick"] = nd.NodeID;
           

        }


        /// <summary>
        /// Guardamos la posicion del Nodo cuando se desplaza
        /// </summary>
        /// <param name="o"></param>
        /// <param name="e"></param>
        protected void NodoReposicionado(object o, NodeRepositionEventArgs e)
        {
            NodeRepositionEventArgs nr = (NodeRepositionEventArgs)e;
            foreach (DiagramNode dn in DiagramContainer1.AllNodes)
            {
                if (dn.NodeID == nr.NodeName)
                {
                    dn.XPos = nr.X;
                    dn.YPos = nr.Y;
                }
            }
        }








        /// <summary>
        /// Recargar el combobox con la lista de nodos
        /// </summary>
        private void refrescarListadoDeNodos()
        {

     

        }



      

        private void crearNodoPadre(string nodoName,string nodoID)
        {

         
            // El anterior->
            nodoName = recortarAnCaracteres(nodoName, longitudNombreCuaderno);

            DiagramNode nodo = new Heckel.EasyTools.Diagramming.DiagramNode("../images/activityType" + getActivityType(nodoID) + ".png", nodoName, "Cuaderno",
                                                                            nodoID, 0, 10, 10, new List<string>(),
                                                                            new List<string>());

            DiagramContainer1.AllNodes.Add(nodo);
          
            salvarDiagramaASession();
         
        }


        /// <summary>
        /// Agrega un nodo nuevo enlazado con un Padre
        /// </summary>
        /// <param name="idPadre">Nombre del Nodo Padre</param>
        /// <param name="nodoName">Nombre del Nodo a enlazar</param>
        private void agregarNodo(string idPadre, string nodoName, string nodoID)
        {
            Random r = new Random();


            nodoName = recortarAnCaracteres(nodoName, longitudNombreCuaderno);


            List<string> allParent = new List<string>();


            allParent.Add(idPadre);

            ///········································································
            /// Agregamos el NODO
            ///········································································

            int num = r.Next(1000);

            DiagramNode aux = null;

            foreach (DiagramNode d in DiagramContainer1.AllNodes)
            {
                if (d.NodeID == idPadre)
                {
                    aux = d;
                    break;
                }
            }


            string urlCarpeta = "../images/activityType" + getActivityType(nodoID) + ".png";
            DiagramContainer1.AllNodes.Add(new Heckel.EasyTools.Diagramming.DiagramNode(urlCarpeta, nodoName, "Cuaderno", nodoID, num, aux.XPos+70, aux.YPos + 120, new List<string>(), allParent));


            ///········································································
            /// Buscamos las relaciones familiares
            ///········································································
            DiagramNode nodoPadre = null;
            DiagramNode nodoActual = null;
            //DiagramNode nodoHijo = null;
            foreach (DiagramNode dn2 in DiagramContainer1.AllNodes)
            {
                if (dn2.NodeID == idPadre)
                    nodoPadre = dn2;
                if (dn2.NodeID == nodoName)
                    nodoActual = dn2;

            }


            ///········································································
            /// Reenlazamos las relaciones
            ///········································································

            try
            {
                DiagramContainer1.AllNodes[DiagramContainer1.AllNodes.IndexOf(nodoPadre)].ParentOfIds.Clear();
                DiagramContainer1.AllNodes[DiagramContainer1.AllNodes.IndexOf(nodoPadre)].ParentOfIds.Add(nodoActual.NodeID);

            }
            catch (Exception ex)
            {
               // //logger.Error(ex.ToString());
            }

            salvarDiagramaASession();
            ///········································································
            /// Refrescamos
            ///········································································

     
        }

        private string getActivityType(string nodoID)
        {
            SqlConnection cn = new SqlConnection(ConfigurationManager.ConnectionStrings["gesworkConnectionString"].ConnectionString);

            SqlDataAdapter daCliente = new SqlDataAdapter("Select [OwneRByType] FROM Activity where id = " + nodoID, cn);
            DataSet ds = new DataSet();
            daCliente.Fill(ds, "Activity");

            return ds.Tables["Activity"].Rows[0][0].ToString();
        }

        /// <summary>
        /// Código secunadario para borrar directorio sin perder session
        /// </summary>
        /// <param name="url"></param>
        private void BorrarDirectorio(string url)
        {

            string[] ficheros = Directory.GetFiles(url);

            foreach (string fichero in ficheros)
            {
                File.Delete(fichero);
            }

            string[] directorios = Directory.GetDirectories(url);

            foreach (string directorio in directorios)
            {
                BorrarDirectorio(directorio);
            }

            //Directory.Delete(url);
        }

        private void CopiaDirectorio(string origen, string destino)
        {
            Directory.CreateDirectory(destino);

            string[] ficheros = Directory.GetFiles(origen);

            foreach (string fichero in ficheros)
            {
                FileInfo f = new FileInfo(fichero);
                f.MoveTo(destino + f.Name);
                //File.Move(fichero,destino+fichero);
            }

            string[] directorios = Directory.GetDirectories(origen);

            foreach (string directorio in directorios)
            {
                DirectoryInfo d = new DirectoryInfo(directorio);
                CopiaDirectorio(directorio, destino + "/" + d.Name);
            }


            BorrarDirectorio(origen);
        }

        /// <summary>
        /// Eliminamos el nodo y sus relaciones
        /// </summary>
        /// <param name="idNodo">ID del Nodo a eleminar</param>
        private void eliminarNodo(string idNodo)
        {
            //Nodo a borrar
            DiagramNode dnborrar = null;

            //string urlScorm = Server.MapPath("./tmp/" + ((ScormCreacion.ScormCreacion)Session["scorm"]).ObtenerId() + "/" + idNodo);
            string urlScorm = "";

            if (Directory.Exists(urlScorm))
                BorrarDirectorio(urlScorm);

            if (File.Exists(urlScorm + ".zip"))
            {
                File.Delete(urlScorm + ".zip");
            }

            //Recorremos todos los nodos hasta encontrar el bueno
            foreach (DiagramNode dn in DiagramContainer1.AllNodes)
            {

                //Comprobamos si es PADRE de algun nodo
                if ((dn.ParentOfIds.Count > 0))
                {
                    //Comprobamos que sea el nodo que buscamos
                    if (dn.NodeID == idNodo)
                    {
                        //Reenlazamos las relaciones
                        DiagramNode nodoPadre = null;
                        DiagramNode nodoActual = null;
                        DiagramNode nodoHijo = null;
                        foreach (DiagramNode dn2 in DiagramContainer1.AllNodes)
                        {

                            if (dn.ParentOfIds.Count == 0)
                            {
                            }
                            else
                            {
                                if (dn2.NodeID == dn.ParentOfIds[0])
                                    nodoPadre = dn2;
                            }

                            if (dn2.NodeID == dn.NodeID)
                                nodoActual = dn2;

                            if (dn.ChildOfIds.Count == 0)
                            {
                            }
                            else
                            {
                                if (dn2.NodeID == dn.ChildOfIds[0])
                                    nodoHijo = dn2;
                            }
                        }

                        if (nodoPadre != null)
                        {
                            nodoPadre.ChildOfIds.Clear();
                            if (nodoHijo != null)
                            {
                                nodoPadre.ChildOfIds.Add(nodoHijo.NodeID);
                            }
                        }
                        // DiagramContainer1.AllNodes[DiagramContainer1.AllNodes.IndexOf(nodoPadre)].ChildOfIds = DiagramContainer1.AllNodes[DiagramContainer1.AllNodes.IndexOf(nodoActual)].ChildOfIds;
                        if (nodoHijo != null)
                        {
                            nodoHijo.ParentOfIds.Clear();
                            if (nodoPadre != null)
                            {
                                nodoHijo.ParentOfIds.Add(nodoPadre.NodeID);
                            }
                        }
                        //   DiagramContainer1.AllNodes[DiagramContainer1.AllNodes.IndexOf(nodoHijo)].ParentOfIds = DiagramContainer1.AllNodes[DiagramContainer1.AllNodes.IndexOf(nodoActual)].ParentOfIds;


                        //Eliminamos el nodo
                        dnborrar = dn;
                        //DiagramContainer1.AllNodes.Remove(dn);
                        break;
                    }
                }

                else //No tiene hijos, se le puede dar muerte.
                {
                    string padre = null;
                    if (dn.NodeID == idNodo)
                    {
                        if (dn.ChildOfIds.Count != 0)
                            padre = dn.ChildOfIds[0];
                        //Eliminamos el nodo en si
                        dnborrar = dn;
                        //DiagramContainer1.AllNodes.Remove(dn);
                    }
                    //Eliminamos las relaciones del nodo
                    foreach (DiagramNode dn2 in DiagramContainer1.AllNodes)
                    {

                        //if (dn2.ParentOfIds.Contains(idNodo))
                        //{
                        //    dn2.ParentOfIds.Remove(idNodo);
                        //}

                        //Como cada nodo solo tiene un padre y un hijo
                        if (dn2.NodeID == padre)
                        {
                            dn2.ParentOfIds.Clear();
                            break;
                        }

                    }

                }

            }

            if (dnborrar != null)
            {
                DiagramContainer1.AllNodes.Remove(dnborrar);
            }



            //ActualizaPos();

            if (DiagramContainer1.AllNodes.Count == 0)
            {
                //btnEliminar.Visible = false;
                //lblCuaderno.Visible = false;
                //lblSeguidoDe.Visible = false;
                //cmbNodos.Visible = false;
            }

            //List<Cuaderno> l = (List<Cuaderno>)Session["lstCuadernos"];
            //int posborrar = 0;
            //for (int i = 0; i < l.Count; i++)
            //{
            //    if (l[i].Nombre == dnborrar.NodeID)
            //    {
            //        posborrar = i;
            //    }
            //}
            //l.Remove(l[posborrar]);
            //Session["lstCuadernos"] = l;


            //para actualizar las imageUrl de cada nodo tras las operaciones
            actualizaCarpetas(DiagramContainer1);


            salvarDiagramaASession();
            //refrescarListadoDeNodos();
            //logger.Debug("Eliminar nodo finalizado " + idNodo);
        }


        /// <summary>
        /// Función para actualizar las imagenes de los nodos
        /// </summary>
        /// <param name="cont"></param>
        private void actualizaCarpetas(DiagramContainer cont)
        {
            int num;
            foreach (DiagramNode node in cont.AllNodes)
            {
                if (node.ImageUrl.Contains("carpetaError"))
                {
                    num = node.ChildOfIds.Count;
                    if (num == 0)
                        node.ImageUrl = "../images/activityError.png";
                    else
                        node.ImageUrl = "../images/activityErrorFlecha.png";
                }
                else
                {
                    num = node.ChildOfIds.Count;
                    if (num == 0)
                        node.ImageUrl = "../images/activity.png";
                    else
                        node.ImageUrl = "../images/activityflecha.png";
                }
            }
        }



        /// <summary>
        /// Reposiciona un nodo en la posición indicada, cambiando así la posición de los demás
        /// </summary>
        private void Reposicionar(string idNodo, int nuevapos)
        {
            if (Session["diagrama"] != null)
            {
                DiagramContainer1 = (DiagramContainer)Session["diagrama"];
            }

           //Añadimos el nodo en la posición indicada

            if (nuevapos == 0)
            {
                DiagramNode npadre = null;
                DiagramNode nactual = null;
                DiagramNode nhijo = null;
                DiagramNode ndestino = null;

                string padre = "", hijo = "";
                //Recorremos todos los nodos hasta encontrar el bueno
                foreach (DiagramNode dn in DiagramContainer1.AllNodes)
                {
                    if (dn.NodeID == idNodo)
                    {
                        nactual = dn;
                        if (dn.ChildOfIds.Count > 0)
                        {
                            padre = dn.ChildOfIds[0];
                            //nhijo.ChildOfIds[0] == npadre;
                        }
                        if (dn.ParentOfIds.Count > 0)
                        {
                            hijo = dn.ParentOfIds[0];
                            //npadre.ParentOfIds[0] == nhijo;
                        }
                        break;
                    }
                }

                foreach (DiagramNode dn in DiagramContainer1.AllNodes)
                {
                    if (dn.NodeID == padre)
                    {
                        npadre = dn;
                    }
                    if (dn.NodeID == hijo)
                    {
                        nhijo = dn;
                    }
                }

                if (npadre != null)
                {
                    if (nhijo != null)
                    {
                        if (nhijo.ChildOfIds.Count != 0)
                        {
                            nhijo.ChildOfIds.Clear();
                        }
                        nhijo.ChildOfIds.Add(padre);
                    }
                    else
                    {
                        npadre.ParentOfIds.Clear();
                    }
                }
                if (nhijo != null)
                {
                    if (npadre != null)
                    {
                        if (npadre.ParentOfIds.Count != 0)
                        {
                            npadre.ParentOfIds.Clear();
                        }
                        npadre.ParentOfIds.Add(hijo);
                    }
                    else
                    {
                        //soy el raíz
                    }
                }

                foreach (DiagramNode dn2 in DiagramContainer1.AllNodes)
                {
                    if (dn2.ChildOfIds.Count == 0)
                    {
                        //es el nodo raíz
                        if (nactual.ParentOfIds.Count != 0)
                        {
                            nactual.ParentOfIds.Clear();
                        }
                        nactual.ParentOfIds.Add(dn2.NodeID);
                        if (nactual.ChildOfIds.Count != 0)
                        {
                            nactual.ChildOfIds.Clear();
                        }

                        dn2.ChildOfIds.Add(nactual.NodeID);
                        break;
                    }
                }
            }
            else
            {

                DiagramNode npadre = null;
                DiagramNode nactual = null;
                DiagramNode nhijo = null;
                DiagramNode ndestino = null;

                string padre = "", hijo = "", destino = "";
                //Recorremos todos los nodos hasta encontrar el bueno
                foreach (DiagramNode dn in DiagramContainer1.AllNodes)
                {
                    if (dn.NodeID == idNodo)
                    {
                        nactual = dn;
                        if (dn.ChildOfIds.Count > 0)
                        {
                            padre = dn.ChildOfIds[0];
                            //nhijo.ChildOfIds[0] == npadre;
                        }
                        if (dn.ParentOfIds.Count > 0)
                        {
                            hijo = dn.ParentOfIds[0];
                            //npadre.ParentOfIds[0] == nhijo;
                        }
                        break;
                    }
                }

                foreach (DiagramNode dn in DiagramContainer1.AllNodes)
                {
                    if (dn.NodeID == padre)
                    {
                        npadre = dn;
                    }
                    if (dn.NodeID == hijo)
                    {
                        nhijo = dn;
                    }
                }

                DiagramNode nraiz = null;
                string raiz2 = "";
                foreach (DiagramNode dn2 in DiagramContainer1.AllNodes)
                {
                    if (dn2.ChildOfIds.Count == 0)
                    {
                        //es el nodo raíz

                        if (dn2.NodeID == idNodo)
                        {
                            //el reposicionado es el raíz
                            //tenemos que coger el siguiente como raíz
                            raiz2 = dn2.ParentOfIds[0];
                        }
                        nraiz = dn2;

                        break;
                    }
                }

                if (raiz2 != "")
                {
                    foreach (DiagramNode dn2 in DiagramContainer1.AllNodes)
                    {
                        if (dn2.NodeID == raiz2)
                        {
                            nraiz = dn2;
                        }
                    }
                }

                if (npadre != null)
                {
                    if (nhijo != null)
                    {
                        if (nhijo.ChildOfIds.Count != 0)
                        {
                            nhijo.ChildOfIds.Clear();
                        }
                        nhijo.ChildOfIds.Add(padre);
                    }
                    else
                    {
                        npadre.ParentOfIds.Clear();
                    }
                }
                else
                {
                    //es el raíz
                    if (nhijo != null)
                    {
                        nhijo.ChildOfIds.Clear();

                    }
                    else
                    {
                        //solo está ese nodo
                    }
                }
                if (nhijo != null)
                {
                    if (npadre != null)
                    {
                        if (npadre.ParentOfIds.Count != 0)
                        {
                            npadre.ParentOfIds.Clear();
                        }
                        npadre.ParentOfIds.Add(hijo);
                    }
                    else
                    {
                        //soy el raíz
                    }
                }

                string padredestino = "";

       
                destino = nraiz.NodeID;
                for (int i = 0; i < nuevapos; i++)
                {

                    if (i == nuevapos - 1)
                    {
                        padredestino = destino;
                    }
                    foreach (DiagramNode d in DiagramContainer1.AllNodes)
                    {
                        if (d.NodeID == destino)
                        {
                            if (d.ParentOfIds.Count != 0)
                            {
                                destino = d.ParentOfIds[0];
                                break;
                            }
                            else
                                destino = "";
                        }
                    }


                }

                DiagramNode npadredestino = null;
                foreach (DiagramNode dn in DiagramContainer1.AllNodes)
                {
                    if (dn.NodeID == destino)
                    {
                        ndestino = dn;
                    }
                    if (dn.NodeID == padredestino)
                    {
                        npadredestino = dn;
                    }

                }

                if (ndestino != null)
                {
                    ndestino.ChildOfIds.Clear();
                }
                if (ndestino != null)
                    ndestino.ChildOfIds.Add(nactual.NodeID);
                nactual.ParentOfIds.Clear();
                if (ndestino != null)
                    nactual.ParentOfIds.Add(ndestino.NodeID);


                if (npadredestino != null)
                {
                    if (npadredestino.ParentOfIds.Count != 0)
                    {
                        npadredestino.ParentOfIds.Clear();
                    }
                    npadredestino.ParentOfIds.Add(nactual.NodeID);
                    nactual.ChildOfIds.Clear();
                    nactual.ChildOfIds.Add(npadredestino.NodeID);
                }
            }


            //actualizamos posicionamiento en listbox

     
            //para actualizar las imageUrl de cada nodo tras las operaciones
            actualizaCarpetas(DiagramContainer1);


            salvarDiagramaASession();
            //ActualizaPos();
            //logger.Debug("Reposicionar finalizado " + idNodo + "  nueva posición " + nuevapos);

        }

        private void ActualizaPos()
        {
      

        }


        /// <summary>
        /// Guarda el diagrama actual a lstCuadernos
        /// </summary>
        private void salvarDiagramaASession()
        {
            Session["diagrama"] = DiagramContainer1;
        }


        private void managePost()
        {
            //try
            //{
            //    FileUploaderAJAX fu = fileUpload1;

            //    int auxda = fu.Controls.Count;
            //    fu.text_Delete = "";
            //    HttpPostedFileAJAX pf = fu.PostedFile;

            //    //if (fu.History == null)
            //    //if (Session["cuadernosSubidos"] !=null)
            //    //    cuadernosSubidos = (List<string>)Session["cuadernosSubidos"];
            //    /*
            //    if (Session["lstCuadernos"] != null)
            //    {
            //        lstCuadernos = (List<Cuaderno>)Session["lstCuadernos"];
            //    }*/

            //    //fu.History.Add(pf);
            //    ScormCreacion.ScormCreacion scorm = (ScormCreacion.ScormCreacion)Session["scorm"];
            //    string au = pf.FileName.Substring(pf.FileName.Length - 4);
            //    //logger.Debug("Subiendo fichero: " + pf.FileName);
            //    if (pf.FileName.Substring(pf.FileName.Length - 4) == ".zip")//pf.Type == HttpPostedFileAJAX.fileType.zip)// && pf.ContentLength <= 5 * 1024)
            //    {
            //        string nombreFichero = pf.FileName.Substring(0, pf.FileName.Length - 4);

            //        nombreFichero = recortarAnCaracteres(nombreFichero, longitudNombreCuaderno);

            //        fu.SaveAs("./tmp/" + scorm.ObtenerId(), nombreFichero + ".zip");
            //        //  string nombreFichero = pf.FileName.Substring(0, pf.FileName.Length - 4);
            //        // ddlistaCuadernos.Items.Add(nombreFichero);
            //        //cuadernosSubidos = (List<string>)Session["cuadernosSubidos"];
            //        //if (cuadernosSubidos == null)
            //        //    cuadernosSubidos = new List<string>();
            //        //cuadernosSubidos.Add(nombreFichero);
            //        //Session["cuadernoSsmarubidos"] = cuadernosSubidos;
            //    }
            //    //string aux=pf.responseMessage_Uploaded_NotSaved;
            //    //pf.responseMessage_Uploaded_NotSaved = "Subido Incorrectamente";
            //    string assu = pf.responseMessage_Uploaded;
            //    pf.responseMessage_Uploaded = pf.FileName;
            //    // QUITAR COMENTARIO SIGUIENTE LINEA para lo del nombre repetido
            //    pf.FileName_SavedAs += DateTime.Now.ToString().Replace(":", "_").Replace(" ", "_").Replace("/", "_");
            //    //refrescarListadoDeNodos();
            //    //logger.Debug("Archivo subido fileUpload a " + "./tmp/" + scorm.ObtenerId());
            //}
            //catch (Exception e)
            //{
            //    //logger.Error(e);
            //}
        }


      





        private int numeroCuaderno()
        {
            if (Session["numeroCuaderno"] != null)
            {
            }
            else
            {
                Session["numeroCuaderno"] = 0;
            }

            int num = (int)Session["numeroCuaderno"];

            num++;
            if (num > 1000)
                num = 0;

            Session["numeroCuaderno"] = num;
            return num;
        }

        protected string preAddFUA()
        {
            //StringBuilder sb = new StringBuilder();

         
            //return sb.ToString();
            return "";
        }

        private string postUploadScript()
        {
            //StringBuilder sb = new StringBuilder();
            //sb.Append("var r=parent.document.getElementById('" + FakeRefreshButton.ClientID + "');");
            ////sb.Append("debugger;");
            //sb.Append("r.click();");
            //return sb.ToString();
            return "";
        }

        private void postAddFUA()
        {
            ////logger.Debug("Comienzo evento postAddFua " + DateTime.Now);

            //string nombreFichero = fileUpload1.PostedFile.FileName.Substring(0,
            //                                                                 fileUpload1.PostedFile.FileName.Length -
            //                                                                 4);
            //nombreFichero = recortarAnCaracteres(nombreFichero, longitudNombreCuaderno);


            //if (Session["diagrama"] != null)
            //{
            //    DiagramContainer1 = (DiagramContainer)Session["diagrama"];
            //}


            //if (DiagramContainer1.AllNodes.Count > 0)
            //{
            //    DiagramNode destino = null;
            //    for (int i = 0; i < DiagramContainer1.AllNodes.Count; i++)
            //    {
            //        if (DiagramContainer1.AllNodes[i].ParentOfIds.Count == 0)
            //        {
            //            destino = DiagramContainer1.AllNodes[i];
            //        }
            //    }
            //    agregarNodo(destino.NodeID, nombreFichero);

            //}
            //else
            //{
            //    crearNodoPadre(nombreFichero);
            //}





            //ScormCreacion.ScormCreacion scorm = (ScormCreacion.ScormCreacion)Session["scorm"];
            //managePost();
            ////string nombreFichero = fileUpload1.PostedFile.FileName.Substring(0, fileUpload1.PostedFile.FileName.Length - 4);
            //nombreFichero = recortarAnCaracteres(nombreFichero, longitudNombreCuaderno);

            //if (fileUpload1.PostedFile.FileName.Substring(fileUpload1.PostedFile.FileName.Length - 4) == ".zip")
            //{
            //    List<Cuaderno> lstCuadernos = (List<Cuaderno>)Session["lstCuadernos"];

        

            //    string urlScorm = Server.MapPath("tmp/" + scorm.ObtenerId() + "/" + nombreFichero + ".zip");
            //    string cuaderno = nombreFichero;//fileUpload1.PostedFile.FileName.Substring(0, fileUpload1.PostedFile.FileName.Length - 4);

            //    if (!scorm.ComprobarScorm(urlScorm))
            //    {
            //        // Acciones para borrar el cuaderno por no ser valido

            //        // En el caso de no ser válido el cuaderno habría que quitarlo de cuadernosSubidos
            //        //lstCuadernos = (List<Cuaderno>)Session["lstCuadernos"];
            //        //eliminarNodo(cuaderno);
            //        //lstCuadernos.Remove(DameCuadernoPorNombre(cuaderno));
            //        //DiagramContainer1.AllNodes.Remove(cuaderno);
            //        //Session["lstCuadernos"] = lstCuadernos;
            //        lstCuadernos.Add(new Cuaderno(nombreFichero, "", 2));
            //        //foreach (DiagramNode nodo in DiagramContainer1.AllNodes)

            //        //miramos el nodo que añadimos
            //        //DiagramNode nuevo = null;
            //        //foreach (DiagramNode d in DiagramContainer1.AllNodes)
            //        //{
            //        //    if (d.NodeID == nombreFichero)
            //        //    {
            //        //        nuevo = d;
            //        //    }
            //        //}


            //        for (int i = 0; i < fileUpload1.History.Count; i++)
            //        {
            //            if (fileUpload1.History[i].FileName == fileUpload1.PostedFile.FileName)//cuaderno + ".zip")
            //            {
            //                fileUpload1.History[i].responseMessage_Uploaded_Saved = "Cuaderno no scorm Cuadernia";
            //                fileUpload1.History[i].Deleted = true;
            //            }

            //        }

            //        //eliminarNodo(cuaderno);

            //        foreach (DiagramNode nodo in DiagramContainer1.AllNodes)
            //        {
            //            //if (nodo.NodeID == nuevo.NodeID)
            //            //{
            //            //}
            //            //else
            //            //{
            //            int num = nodo.ChildOfIds.Count;
            //            if (nodo.NodeID == cuaderno)
            //            {
            //                if (num == 0)
            //                    nodo.ImageUrl = "../images/activityError.png";
            //                else
            //                    nodo.ImageUrl = "../images/activityErrorFlecha.png";
            //            }
            //            //}
            //        }

            //        File.Delete(Server.MapPath("./tmp/" + scorm.ObtenerId() + "/" + cuaderno + ".zip"));

            //        if (fileUpload1.History != null && scorm != null)
            //        {

            //            HttpPostedFileAJAX ficheroAux = new HttpPostedFileAJAX();
            //            foreach (HttpPostedFileAJAX fich in fileUpload1.History)
            //            {
            //                if (fich.FileName == cuaderno + ".zip")
            //                    ficheroAux = fich;

            //            }
            //            if (!File.Exists(urlScorm))
            //            {
            //                ficheroAux.responseMessage_Uploaded_NotSaved = "Cuaderno no scorm Cuadernia";
            //                ficheroAux.responseMessage_Uploaded_Saved = "Cuaderno no scorm Cuadernia";
            //                ficheroAux.responseMessage_Uploaded = "Cuaderno no scorm Cuadernia";
            //                ficheroAux.FileName = "Cuaderno no scorm Cuadernia";
            //                ficheroAux.Saved = false;
            //            }

            //        }

            //     }
            //    else
            //    {
            //        lstCuadernos.Add(new Cuaderno(cuaderno, urlScorm, 0));
            //        Session["lstCuadernos"] = lstCuadernos;
            //    }


            //}
            //else // en el caso de no ser fichero zip
            //{
            //    foreach (DiagramNode nodo in DiagramContainer1.AllNodes)
            //    {
            //        int num = nodo.ChildOfIds.Count;
            //        if (nodo.NodeID == nombreFichero)
            //        {
            //            if (num == 0)
            //                nodo.ImageUrl = "../images/activityError.png";
            //            else
            //                nodo.ImageUrl = "../images/activityErrorFlecha.png";
            //        }
            //    }

            //    lstCuadernos.Add(new Cuaderno(nombreFichero, "", 2));

            //}


        

        }

        private string DameCuadernoPorNombre(string cuaderno)
        {
            //foreach (Cuaderno c in lstCuadernos)
            //{
            //    if (c.Nombre == cuaderno)
            //    {
            //        return c;
            //    }
            //}
            return ""; //no debería llegar aquí
        }

        private string recortarAnCaracteres(string nombreFichero, int n)
        {
            //Quitamos la denominacion de "cuaderno_scorm_"
            if (nombreFichero.Length > 15)
                if (nombreFichero.Substring(0, 15).ToLower().Equals("cuaderno_scorm_"))
                    nombreFichero = nombreFichero.Substring(15, nombreFichero.Length - 15);

            // Recortamos cuaderno y scorm para dejar el nombre más claro
            nombreFichero = nombreFichero.Replace("cuaderno", "");
            nombreFichero = nombreFichero.Replace("Cuaderno", "");
            nombreFichero = nombreFichero.Replace("scorm", "");
            nombreFichero = nombreFichero.Replace("Scorm", "");
            nombreFichero = nombreFichero.Replace("__", "_");
            nombreFichero = nombreFichero.Replace(" ", "_");

            #region Carácteres que no dejan que se muevan los carácteres

            nombreFichero = nombreFichero.Replace("(", "");
            nombreFichero = nombreFichero.Replace(")", "");
            nombreFichero = nombreFichero.Replace("[", "");
            nombreFichero = nombreFichero.Replace("{", "");
            nombreFichero = nombreFichero.Replace("}", "");
            nombreFichero = nombreFichero.Replace("]", "");
            nombreFichero = nombreFichero.Replace("/", "");
            nombreFichero = nombreFichero.Replace("\\", "");
            nombreFichero = nombreFichero.Replace("%", "");
            nombreFichero = nombreFichero.Replace("#", "");
            nombreFichero = nombreFichero.Replace("@", "");
            nombreFichero = nombreFichero.Replace("-", "");
            nombreFichero = nombreFichero.Replace(",", "");
            nombreFichero = nombreFichero.Replace(";", "");
            nombreFichero = nombreFichero.Replace("=", "");
            nombreFichero = nombreFichero.Replace(":", "");
            nombreFichero = nombreFichero.Replace("?", "");
            nombreFichero = nombreFichero.Replace("¿", "");
            nombreFichero = nombreFichero.Replace("¡", "");
            nombreFichero = nombreFichero.Replace("!", "");

            #endregion

            if (nombreFichero == "" || nombreFichero.Length < 3) nombreFichero = "scorm" + nombreFichero;
            //Eliminamos caracteres no alphanumericos
            NormalizarSinAcentos(nombreFichero);

            //Quitamos puntos que dan problemas en el diagram container
            nombreFichero = nombreFichero.Replace(".", "");

            //Recortamos a un tamaño maximo de n
            if (nombreFichero.Length > n)
                nombreFichero = nombreFichero.Substring(0, n);


            //Comprobamos si ya tenemos alguno con ese nombre y renombramos


            if (Session["lstCuadernos"] != null)
            {
                //lstCuadernos = (List<Cuaderno>)Session["lstCuadernos"];
            }


            //foreach (Cuaderno c in lstCuadernos)
            //{
            //    if (c.Nombre == nombreFichero)
            //    {
            //        int i = 1;
            //        string nombreaux = nombreFichero;
            //        do
            //        {
            //            i++;
            //            nombreFichero = nombreaux + "" + i + "";

            //        } while (Contiene(nombreaux + "" + i + ""));
            //    }
            //}

            return nombreFichero;
        }

        private bool Contiene(string p)
        {
            //foreach (Cuaderno c in lstCuadernos)
            //{
            //    if (c.Nombre == p)
            //    {
            //        return true;
            //    }
            //}
            return false;
        }

        public static string NormalizarSinAcentos(string textoOriginal)
        {

            //transformación UNICODE
            string textoNormalizado = textoOriginal.Normalize(NormalizationForm.FormD);

            //coincide todo lo que no sean letras y números ascii o espacio
            //y lo reemplazamos por una cadena vacía.
            System.Text.RegularExpressions.Regex reg = new System.Text.RegularExpressions.Regex("[^a-no-zA-NO-Z0-9? _\\-\\.]");

            //Eliminamos caracteres raros
            string textoSinAcentos = reg.Replace(textoNormalizado, "");

            //Limitamos la longitud maxima de nombre de fichero a 55 caracteres
            if (textoSinAcentos.Length > 55)
            {
                textoSinAcentos = textoSinAcentos.Substring(0, 55);
            }

            return textoSinAcentos;
        }

        protected void FakeRefreshButton_Click(object sender, EventArgs e)
        {

        }

        protected void BorrarTodos(object sender, EventArgs e)
        {
            DiagramContainer1.AllNodes.RemoveAll(new Predicate<DiagramNode>(delegate(DiagramNode cNode) { return cNode.NodeID != null; }));
            //lstCuadernos.RemoveAll(new Predicate<Cuaderno>(delegate(Cuaderno c) { return c.Nombre != null; }));
            //fileUpload1.Reset();
            //Session["lstCuadernos"] = lstCuadernos;
            salvarDiagramaASession();
        }

        protected void Reordenar(object sender, EventArgs e)
        {
            if (DiagramContainer1.AllNodes.Count > 0)
            {
                int posy = 0;
                int posx = 0;
                DiagramNode padre = null;
                //Buscamos el nodo padre
                foreach (DiagramNode d in DiagramContainer1.AllNodes)
                {
                    if (d.ChildOfIds.Count == 0)
                    {
                        padre = d;
                    }
                }

                if (padre != null)
                {
                    padre.YPos = posy;
                    padre.XPos = posx;
                }


                //A raíz del nodo padre obtenemos los otros

                int sumandox = 120;
                int sumandoy = 120;
                int num_nodos = 1;
                do
                {
                    foreach (DiagramNode d in DiagramContainer1.AllNodes)
                    {
                        if (d.ChildOfIds.Count > 0)
                        {
                            if (d.ChildOfIds[0] == padre.NodeID)
                            {
                                if (num_nodos % 5 != 0)
                                {
                                    posx += sumandox;
                                }
                                d.YPos = posy;
                                d.XPos = posx;
                                padre = d;
                                num_nodos++;

                                if (num_nodos % 5 == 0)
                                {
                                    posy = posy + sumandoy;
                                    sumandox = -1 * sumandox;
                                }

                                break;
                            }
                        }

                    }
                } while (padre.ParentOfIds.Count > 0);

            }

            StringBuilder sb = new StringBuilder();
            //sb.Append("var r=parent.document.getElementById('" + FakeRefreshButton.ClientID + "');");
            //sb.Append("debugger;");
            sb.Append("r.click();");
            ScriptManager.RegisterStartupScript(this, this.GetType(), "refrescoEliminarHistorial", sb.ToString(), true);

        }





    }
}
